远程调用Linux shell 命令 查看物理主机内存和磁盘空间情况

package cn.gwssi.data.db.monitor.util;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;

import cn.gwssi.data.phoenix.util.Init;

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelExec;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;

/**
 * 远程调用Linux shell 命令 查看物理主机内存和磁盘空间情况
 */

public class HostStateForShell {

	public static final String CPU_MEM_SHELL = "top -b -n 1";
	public static final String DISK_SPACE_SHELL = "df -hl";
	public static final String[] COMMANDS = { CPU_MEM_SHELL, DISK_SPACE_SHELL };
	public static final String LINE_SEPARATOR = System.getProperty("line.separator");
	private static Session session;

	/**
	 * 
	 * 连接到指定的HOST 
	 * @return isConnect
	 * @throws JSchException
	 * 
	 */
	private static boolean connect(String user, String passwd, String host) throws Exception {

		JSch jsch = new JSch();
		boolean flag = false;
		try {
			session = jsch.getSession(user, Init.IPMap1.get(host), 22);
			session.setPassword(passwd);
			java.util.Properties config = new java.util.Properties();
			config.put("StrictHostKeyChecking", "no");
			session.setConfig(config);
			session.connect();
			flag = true;
		} catch (JSchException e) {
			throw new Exception("connect error !", e);
		}
		return flag;
	}

	/**
	 * 
	 * 远程连接Linux 服务器 执行相关的命令
	 * 
	 * @param commands
	 * 
	 *            执行的脚本
	 * 
	 * @param user
	 * 
	 *            远程连接的用户名
	 * 
	 * @param passwd
	 * 
	 *            远程连接的密码
	 * 
	 * @param host
	 * 
	 *            远程连接的主机IP
	 * 
	 * @return 最终命令返回信息
	 * 
	 * @throws Exception
	 */

	public static Map<String, String> runDistanceShell (String user, String passwd, String host) throws Exception {

		if (!connect(user, passwd, host)) {
			return null;
		}

		Map<String, String> map = new HashMap<>();
		StringBuilder stringBuffer;
		BufferedReader reader = null;
		Channel channel = null;
		try {
			for (String command : COMMANDS) {
				stringBuffer = new StringBuilder();
				channel = session.openChannel("exec");
				((ChannelExec) channel).setCommand(command);
				channel.setInputStream(null);
				((ChannelExec) channel).setErrStream(System.err);
				channel.connect();
				InputStream in = channel.getInputStream();
				reader = new BufferedReader(new InputStreamReader(in));
				String buf;
				while ((buf = reader.readLine()) != null) {
					// 舍弃PID 进程信息
					if (buf.contains("PID")) {
						break;
					}
					stringBuffer.append(buf.trim()).append(LINE_SEPARATOR);
				}

				// 每个命令存储自己返回数据-用于后续对返回数据进行处理
				map.put(command, stringBuffer.toString());
			}
		} catch (IOException | JSchException e) {
			e.printStackTrace();
		} finally {
			try {
				if (reader != null) {
					reader.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (channel != null) {
				channel.disconnect();
			}
			session.disconnect();
		}
		return map;
	}

	/**
	 * 
	 * 直接在本地执行 shell
	 * 
	 * @param commands
	 * 
	 *            执行的脚本
	 * 
	 * @return 执行结果信息
	 */

	public static Map<String, String> runLocalShell(String[] commands) {

		Runtime runtime = Runtime.getRuntime();
		Map<String, String> map = new HashMap<>();
		StringBuilder stringBuffer;
		BufferedReader reader;
		Process process;
		for (String command : commands) {
			stringBuffer = new StringBuilder();
			try {
				process = runtime.exec(command);
				InputStream inputStream = process.getInputStream();
				reader = new BufferedReader(new InputStreamReader(inputStream));
				String buf;
				while ((buf = reader.readLine()) != null) {
					// 舍弃PID 进程信息
					if (buf.contains("PID")) {
						break;
					}
					stringBuffer.append(buf.trim()).append(LINE_SEPARATOR);
				}
			} catch (IOException e) {
				e.printStackTrace();
				return null;
			}

			// 每个命令存储自己返回数据-用于后续对返回数据进行处理
			map.put(command, stringBuffer.toString());
		}
		return map;
	}

	/**
	 * 
	 * 处理 shell 返回的信息 具体处理过程以服务器返回数据格式为准 不同的Linux 版本返回信息格式不同
	 * 
	 * @param result
	 * 
	 *            shell 返回的信息
	 * 
	 * @return 最终处理后的信息
	 */

	public static Map<String, String> disposeResultMessage(
			Map<String, String> result) {

		Map<String, String> mapInfo = new HashMap<String, String>();
		for (String command : COMMANDS) {
			String commandResult = result.get(command);
			if (null == commandResult)
				continue;
			if (command.equals(CPU_MEM_SHELL)) {
				String[] strings = commandResult.split(LINE_SEPARATOR);
				// 将返回结果按换行符分割
				for (String line : strings) {
					line = line.toUpperCase();// 转大写处理
					// 处理CPU Cpu(s): 10.8%us, 0.9%sy, 0.0%ni, 87.6%id, 0.7%wa,
					// 0.0%hi, 0.0%si, 0.0%st
					if (line.contains("CPU")) {
						String cpuStr = "";
						try {
							cpuStr += line.split(":")[1].split(",")[0].replace("US", "");
							mapInfo.put(Init.CPU_USE, cpuStr);
						} catch (Exception e) {
							e.printStackTrace();
						}

						// 处理内存 Mem: 66100704k total, 65323404k used, 777300k
						// free, 89940k buffers
					} else if (line.contains("MEM") && !(line.contains("SWAP"))) {
						String memStr = "";
						try {
							memStr += line.split(":")[1].replaceAll("TOTAL", "").replaceAll("USED", "").replaceAll("FREE", "");
							mapInfo.put(Init.MEMORY_USE_INFO, memStr);
						} catch (Exception e) {
							e.printStackTrace();
							continue;
						}
					}
				}
			} else if (command.equals(DISK_SPACE_SHELL)) {
				// 处理系统磁盘状态
				try {
					mapInfo.put(Init.DISK_USE_INFO, disposeFilesSystem(commandResult));
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		return mapInfo;
	}

	/**
	 * 
	 * 处理系统磁盘状态 Filesystem Size Used Avail Use% Mounted on /dev/sda3 442G 327G
	 * 
	 * 93G 78% / tmpfs 32G 0 32G 0% /dev/shm /dev/sda1 788M 60M 689M 8% /boot
	 * 
	 * /dev/md0 1.9T 483G 1.4T 26% /ezsonar
	 * 
	 * @param commandResult
	 * 
	 *            处理系统磁盘状态shell执行结果
	 * 
	 * @return 处理后的结果
	 */

	private static String disposeFilesSystem(String commandResult) {

		List<String> list = new ArrayList<>();
		String[] strings = commandResult.split(LINE_SEPARATOR);
		String size = "";
		String used = "";
		String free = "";
		for (int i = 0; i < 2; i++) {
			if (i == 0)
				continue;
			int temp = 0;
			if (strings[i].contains("dev")) {
				String[] ss = strings[i].split(" ");
				for (int k = 0; k < ss.length; k++) {
					if (StringUtils.isNotBlank(ss[k])) {
						list.add(ss[k]);
					}
				}
				size = String.valueOf(Long.parseLong(list.get(1).replaceAll("G", "")) * 1024);
				// used =
				// String.valueOf(Integer.parseInt(list.get(2).replaceAll(
				// "G", "")) );
				free = String.valueOf(Long.parseLong(list.get(3).replaceAll("G", "")) * 1024);
			}
			// for (String s : strings[i].split("\\b")) {
			// if (temp == 0) {
			// temp++;
			// continue;
			// }
			// if (!s.trim().isEmpty()) {
			// if (temp == 1) {
			// size += disposeUnit(s);
			// temp++;
			// } else {
			// used += disposeUnit(s);
			// temp = 0;
			// }
			// }
			// }
		}
		// return new StringBuilder().append(size).append("G").append(" ")
		// .append(used).append("G").append(" ").append(size - used)
		// .append("G").toString();
		return new StringBuilder().append(size).append(" ").append(free).toString();

	}

	/**
	 * 
	 * 处理单位转换 K/KB/M/T 最终转换为G 处理
	 * 
	 * @param s
	 * 
	 *            带单位的数据字符串
	 * 
	 * @return 以G 为单位处理后的数值
	 */

	private static int disposeUnit(String s) {

		try {
			s = s.toUpperCase();
			String lastIndex = s.substring(s.length() - 1);
			String num = s.substring(0, s.length() - 1);
			int parseInt = Integer.parseInt(num);
			// System.out.println(parseInt);
			if (lastIndex.equals("G")) {
				return parseInt;
			} else if (lastIndex.equals("T")) {
				return parseInt * 1024;
			} else if (lastIndex.equals("M")) {
				return parseInt / 1024;
			} else if (lastIndex.equals("K") || lastIndex.equals("KB")) {
				return parseInt / (1024 * 1024);
			}
		} catch (NumberFormatException e) {
			e.printStackTrace();
			return 0;
		}
		return 0;
	}
}